// src/utils/AddressDict.js
import addressData from '../constants/address_dict.json';

class AddressDict {
  constructor() {
    this.data = addressData;
    this.codeToName = new Map();
    this.nameToCode = new Map();
    this.parentToChildren = new Map();

    this.buildIndex();
  }

  buildIndex() {
    // 递归处理树形结构数据
    const processNode = (node, level) => {
      const code = node.code.toString();
      const name = node.name;
      const parentId = node.parentId.toString();

      // 存储代码和名称的映射
      this.codeToName.set(code, name);
      this.nameToCode.set(name, code);

      // 构建父级到子级的映射
      if (!this.parentToChildren.has(parentId)) {
        this.parentToChildren.set(parentId, []);
      }
      this.parentToChildren.get(parentId).push({
        code: code,
        name: name,
        level: level
      });

      // 递归处理子节点
      if (node.children && Array.isArray(node.children)) {
        node.children.forEach(child => {
          processNode(child, level + 1);
        });
      }
    };

    // 处理根节点的子节点（市级）
    this.data.forEach(node => {
      processNode(node, 1); // 市级为level 1
    });
  }

  // 标准化代码：将输入代码转换为字符串格式
  normalizeCode(inputCode) {
    if (!inputCode) return '';
    return inputCode.toString();
  }

  // 反向标准化：直接返回代码字符串（因为yunnan_region_code.json中的代码已经是不含前导0的格式）
  denormalizeCode(standardCode) {
    if (!standardCode) return '';
    return standardCode.toString();
  }

  // 获取所有市级
  getCities() {
    return this.parentToChildren.get('0') || [];
  }

  // 根据父级代码获取子级
  getChildrenByParentCode(parentCode) {
    const normalizedParentCode = this.normalizeCode(parentCode);
    return this.parentToChildren.get(normalizedParentCode) || [];
  }

  // 根据代码获取名称（支持省略前导0的代码）
  getNameByCode(inputCode) {
    const normalizedCode = this.normalizeCode(inputCode);
    return this.codeToName.get(normalizedCode) || '';
  }

  // 根据名称获取代码（返回标准格式）
  getCodeByName(name) {
    return this.nameToCode.get(name);
  }

  // 获取级联选择器数据
  getCascadeOptions() {
    return this.getCities().map((city) => ({
      value: this.denormalizeCode(city.code), // 前端使用可能省略前导0的格式
      label: city.name,
      children: this.getChildrenByParentCode(city.code).map((district) => ({
        value: this.denormalizeCode(district.code),
        label: district.name,
        children: this.getChildrenByParentCode(district.code).map((street) => ({
          value: this.denormalizeCode(street.code),
          label: street.name,
        })),
      })),
    }));
  }

  // 根据代码数组获取完整路径（支持省略前导0的代码）
  getFullPathByCodes(codes) {
    return codes.map((code) => this.getNameByCode(code)).join('-');
  }

  // 根据最终代码获取完整路径
  getFullPath(inputCode) {
    const code = this.normalizeCode(inputCode);
    if (!code || !this.codeToName.has(code)) return '';

    // 从街道开始，向上查找父级
    let currentCode = code;
    const path = [];
    
    // 先添加当前节点名称
    path.push(this.codeToName.get(currentCode));
    
    // 查找父级节点，直到找到根节点
    while (currentCode) {
      // 查找当前节点的父级代码
      let parentCode = null;
      for (const [parent, children] of this.parentToChildren.entries()) {
        if (children.some(child => child.code === currentCode)) {
          parentCode = parent;
          break;
        }
      }
      
      if (parentCode && parentCode !== '0' && this.codeToName.has(parentCode)) {
        path.unshift(this.codeToName.get(parentCode));
        currentCode = parentCode;
      } else {
        break;
      }
    }
    
    return path.join('-');
  }

  // 验证代码是否有效（支持省略前导0的代码）
  isValidCode(inputCode) {
    const normalizedCode = this.normalizeCode(inputCode);
    return this.codeToName.has(normalizedCode);
  }

  // 根据最终代码获取各级代码
  getLevelCodes(inputCode) {
    const code = this.normalizeCode(inputCode);
    if (!code || !this.codeToName.has(code)) return [];

    const codes = [];
    let currentCode = code;
    
    // 从街道开始，向上查找父级
    codes.unshift(currentCode);
    
    // 最多查找3级（市、区、街道）
    let levelsFound = 1;
    while (currentCode && levelsFound < 3) {
      // 查找当前节点的父级代码
      let parentCode = null;
      for (const [parent, children] of this.parentToChildren.entries()) {
        if (children.some(child => child.code === currentCode)) {
          parentCode = parent;
          break;
        }
      }
      
      if (parentCode && parentCode !== '0' && this.codeToName.has(parentCode)) {
        codes.unshift(parentCode);
        currentCode = parentCode;
        levelsFound++;
      } else {
        break;
      }
    }
    
    // 确保返回3级代码（如果不足则补空字符串）
    while (codes.length < 3) {
      codes.unshift('');
    }
    
    return codes;
  }

  // 根据各级代码生成最终代码
  getFinalCode(cityCode, districtCode, streetCode) {
    // 在新的格式中，直接返回街道代码即可，因为它已经包含了完整的层级信息
    // 如果没有提供街道代码但有区县代码，则返回区县代码
    // 如果只有城市代码，则返回城市代码
    if (streetCode) {
      return this.normalizeCode(streetCode);
    } else if (districtCode) {
      return this.normalizeCode(districtCode);
    } else if (cityCode) {
      return this.normalizeCode(cityCode);
    }
    return '';
  }
}

// 创建单例实例
const addressDict = new AddressDict();

export default addressDict;
